package com.school.sports.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.school.sports.entity.CertificateTemplate;
import com.school.sports.mapper.CertificateTemplateMapper;
import com.school.sports.service.CertificateTemplateService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * 证书模板服务实现类
 */
@Service
public class CertificateTemplateServiceImpl extends ServiceImpl<CertificateTemplateMapper, CertificateTemplate> implements CertificateTemplateService {

    private static final Logger logger = LoggerFactory.getLogger(CertificateTemplateServiceImpl.class);

    @Override
    public IPage<CertificateTemplate> getPage(int currentPage, int pageSize, CertificateTemplate template) {
        Page<CertificateTemplate> page = new Page<>(currentPage, pageSize);
        return baseMapper.selectTemplatePageWithUserName(page, template);
    }

    @Override
    public List<CertificateTemplate> getTemplatesByType(String templateType) {
        if (!StringUtils.hasText(templateType)) {
            return new ArrayList<>();
        }
        return baseMapper.selectByTypeAndStatus(templateType, "active");
    }

    @Override
    public CertificateTemplate getDefaultTemplateByType(String templateType) {
        if (!StringUtils.hasText(templateType)) {
            return null;
        }
        return baseMapper.selectDefaultTemplateByType(templateType);
    }

    @Override
    public boolean createTemplate(CertificateTemplate template, Long createUserId) {
        if (template == null || !StringUtils.hasText(template.getTemplateName()) ||
            !StringUtils.hasText(template.getTemplateType())) {
            logger.error("创建证书模板失败：参数不完整");
            return false;
        }

        try {
            // 如果设置为默认模板，先将同类型的其他模板设置为非默认
            if (Boolean.TRUE.equals(template.getIsDefault())) {
                LambdaUpdateWrapper<CertificateTemplate> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(CertificateTemplate::getTemplateType, template.getTemplateType())
                           .set(CertificateTemplate::getIsDefault, false);
                update(updateWrapper);
            }

            // 设置创建信息
            template.setCreateUserId(createUserId);
            template.setCreatedAt(LocalDateTime.now());
            template.setUpdatedAt(LocalDateTime.now());

            // 如果没有指定状态，默认为active
            if (!StringUtils.hasText(template.getStatus())) {
                template.setStatus("active");
            }

            boolean result = save(template);
            if (result) {
                logger.info("证书模板创建成功，模板名称：{}, 类型：{}", template.getTemplateName(), template.getTemplateType());
            } else {
                logger.error("证书模板创建失败，模板名称：{}", template.getTemplateName());
            }
            return result;

        } catch (Exception e) {
            logger.error("创建证书模板异常：{}", e.getMessage(), e);
            return false;
        }
    }

    @Override
    public boolean updateTemplate(CertificateTemplate template) {
        if (template == null || template.getId() == null) {
            logger.error("更新证书模板失败：参数不完整");
            return false;
        }

        try {
            CertificateTemplate existingTemplate = getById(template.getId());
            if (existingTemplate == null) {
                logger.error("更新证书模板失败：模板不存在，ID：{}", template.getId());
                return false;
            }

            // 如果设置为默认模板，先将同类型的其他模板设置为非默认
            if (Boolean.TRUE.equals(template.getIsDefault()) &&
                !Boolean.TRUE.equals(existingTemplate.getIsDefault())) {
                LambdaUpdateWrapper<CertificateTemplate> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(CertificateTemplate::getTemplateType, template.getTemplateType())
                           .ne(CertificateTemplate::getId, template.getId())
                           .set(CertificateTemplate::getIsDefault, false);
                update(updateWrapper);
            }

            // 更新信息
            template.setUpdatedAt(LocalDateTime.now());

            boolean result = updateById(template);
            if (result) {
                logger.info("证书模板更新成功，ID：{}", template.getId());
            } else {
                logger.error("证书模板更新失败，ID：{}", template.getId());
            }
            return result;

        } catch (Exception e) {
            logger.error("更新证书模板异常：{}", e.getMessage(), e);
            return false;
        }
    }

    @Override
    public boolean setAsDefault(Long templateId, String templateType) {
        if (templateId == null || !StringUtils.hasText(templateType)) {
            logger.error("设置默认模板失败：参数不完整");
            return false;
        }

        try {
            // 先将同类型的其他模板设置为非默认
            LambdaUpdateWrapper<CertificateTemplate> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(CertificateTemplate::getTemplateType, templateType)
                       .set(CertificateTemplate::getIsDefault, false);
            update(updateWrapper);

            // 设置指定模板为默认
            LambdaUpdateWrapper<CertificateTemplate> defaultWrapper = new LambdaUpdateWrapper<>();
            defaultWrapper.eq(CertificateTemplate::getId, templateId)
                         .set(CertificateTemplate::getIsDefault, true)
                         .set(CertificateTemplate::getUpdatedAt, LocalDateTime.now());

            boolean result = update(defaultWrapper);
            if (result) {
                logger.info("设置默认模板成功，ID：{}, 类型：{}", templateId, templateType);
            } else {
                logger.error("设置默认模板失败，ID：{}", templateId);
            }
            return result;

        } catch (Exception e) {
            logger.error("设置默认模板异常：{}", e.getMessage(), e);
            return false;
        }
    }

    @Override
    public List<CertificateTemplate> getActiveTemplates() {
        return baseMapper.selectActiveTemplates();
    }

    @Override
    public boolean updateTemplateStatus(Long templateId, String status) {
        if (templateId == null || !StringUtils.hasText(status)) {
            logger.error("更新模板状态失败：参数不完整");
            return false;
        }

        try {
            LambdaUpdateWrapper<CertificateTemplate> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(CertificateTemplate::getId, templateId)
                       .set(CertificateTemplate::getStatus, status)
                       .set(CertificateTemplate::getUpdatedAt, LocalDateTime.now());

            boolean result = update(updateWrapper);
            if (result) {
                logger.info("更新模板状态成功，ID：{}, 状态：{}", templateId, status);
            } else {
                logger.error("更新模板状态失败，ID：{}", templateId);
            }
            return result;

        } catch (Exception e) {
            logger.error("更新模板状态异常：{}", e.getMessage(), e);
            return false;
        }
    }

    @Override
    public boolean deleteTemplate(Long templateId) {
        if (templateId == null) {
            logger.error("删除模板失败：参数不完整");
            return false;
        }

        try {
            boolean result = removeById(templateId);
            if (result) {
                logger.info("删除模板成功，ID：{}", templateId);
            } else {
                logger.error("删除模板失败，ID：{}", templateId);
            }
            return result;

        } catch (Exception e) {
            logger.error("删除模板异常：{}", e.getMessage(), e);
            return false;
        }
    }
}